﻿using System;
using System.ComponentModel;
using System.IO;
using System.Runtime.Serialization;

namespace HalconDotNet
{
	/// <summary>Represents an instance of a deformable model for matching.</summary>
	// Token: 0x0200002D RID: 45
	[Serializable]
	public class HDeformableModel : HHandle, ISerializable, ICloneable
	{
		// Token: 0x060003F0 RID: 1008 RVA: 0x0000883B File Offset: 0x00006A3B
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HDeformableModel() : base(HHandleBase.UNDEF)
		{
		}

		// Token: 0x060003F1 RID: 1009 RVA: 0x0001720C File Offset: 0x0001540C
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HDeformableModel(IntPtr handle) : base(handle)
		{
			this.AssertSemType();
		}

		// Token: 0x060003F2 RID: 1010 RVA: 0x0001721B File Offset: 0x0001541B
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HDeformableModel(HHandle handle) : base(handle)
		{
			this.AssertSemType();
		}

		// Token: 0x060003F3 RID: 1011 RVA: 0x0001722A File Offset: 0x0001542A
		private void AssertSemType()
		{
			base.AssertSemType("deformable_model");
		}

		// Token: 0x060003F4 RID: 1012 RVA: 0x00017237 File Offset: 0x00015437
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HDeformableModel obj)
		{
			obj = new HDeformableModel(HHandleBase.UNDEF);
			return obj.Load(proc, parIndex, err);
		}

		// Token: 0x060003F5 RID: 1013 RVA: 0x00017250 File Offset: 0x00015450
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HDeformableModel[] obj)
		{
			HTuple htuple;
			err = HTuple.LoadNew(proc, parIndex, err, out htuple);
			obj = new HDeformableModel[htuple.Length];
			for (int i = 0; i < htuple.Length; i++)
			{
				obj[i] = new HDeformableModel(HalconAPI.IsLegacyHandleMode() ? htuple[i].IP : htuple[i].H);
			}
			htuple.Dispose();
			return err;
		}

		/// <summary>
		///   Read a deformable model from a file.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="fileName">File name.</param>
		// Token: 0x060003F6 RID: 1014 RVA: 0x000172C0 File Offset: 0x000154C0
		public HDeformableModel(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(965);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Prepare a deformable model for planar calibrated matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="camParam">The parameters of the internal orientation of the camera.</param>
		/// <param name="referencePose">The reference pose of the object.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameter. Default: []</param>
		// Token: 0x060003F7 RID: 1015 RVA: 0x0001730C File Offset: 0x0001550C
		public HDeformableModel(HXLDCont contours, HCamPar camParam, HPose referencePose, HTuple numLevels, HTuple angleStart, HTuple angleExtent, HTuple angleStep, double scaleRMin, HTuple scaleRMax, HTuple scaleRStep, double scaleCMin, HTuple scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(976);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.Store(proc, 0, camParam);
			HalconAPI.Store(proc, 1, referencePose);
			HalconAPI.Store(proc, 2, numLevels);
			HalconAPI.Store(proc, 3, angleStart);
			HalconAPI.Store(proc, 4, angleExtent);
			HalconAPI.Store(proc, 5, angleStep);
			HalconAPI.StoreD(proc, 6, scaleRMin);
			HalconAPI.Store(proc, 7, scaleRMax);
			HalconAPI.Store(proc, 8, scaleRStep);
			HalconAPI.StoreD(proc, 9, scaleCMin);
			HalconAPI.Store(proc, 10, scaleCMax);
			HalconAPI.Store(proc, 11, scaleCStep);
			HalconAPI.Store(proc, 12, optimization);
			HalconAPI.StoreS(proc, 13, metric);
			HalconAPI.StoreI(proc, 14, minContrast);
			HalconAPI.Store(proc, 15, genParamName);
			HalconAPI.Store(proc, 16, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(referencePose);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Prepare a deformable model for planar calibrated matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="camParam">The parameters of the internal orientation of the camera.</param>
		/// <param name="referencePose">The reference pose of the object.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameter. Default: []</param>
		// Token: 0x060003F8 RID: 1016 RVA: 0x0001746C File Offset: 0x0001566C
		public HDeformableModel(HXLDCont contours, HCamPar camParam, HPose referencePose, int numLevels, HTuple angleStart, HTuple angleExtent, double angleStep, double scaleRMin, HTuple scaleRMax, double scaleRStep, double scaleCMin, HTuple scaleCMax, double scaleCStep, string optimization, string metric, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(976);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.Store(proc, 0, camParam);
			HalconAPI.Store(proc, 1, referencePose);
			HalconAPI.StoreI(proc, 2, numLevels);
			HalconAPI.Store(proc, 3, angleStart);
			HalconAPI.Store(proc, 4, angleExtent);
			HalconAPI.StoreD(proc, 5, angleStep);
			HalconAPI.StoreD(proc, 6, scaleRMin);
			HalconAPI.Store(proc, 7, scaleRMax);
			HalconAPI.StoreD(proc, 8, scaleRStep);
			HalconAPI.StoreD(proc, 9, scaleCMin);
			HalconAPI.Store(proc, 10, scaleCMax);
			HalconAPI.StoreD(proc, 11, scaleCStep);
			HalconAPI.StoreS(proc, 12, optimization);
			HalconAPI.StoreS(proc, 13, metric);
			HalconAPI.StoreI(proc, 14, minContrast);
			HalconAPI.Store(proc, 15, genParamName);
			HalconAPI.Store(proc, 16, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(referencePose);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Prepare a deformable model for planar uncalibrated matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		// Token: 0x060003F9 RID: 1017 RVA: 0x000175A8 File Offset: 0x000157A8
		public HDeformableModel(HXLDCont contours, HTuple numLevels, HTuple angleStart, HTuple angleExtent, HTuple angleStep, double scaleRMin, HTuple scaleRMax, HTuple scaleRStep, double scaleCMin, HTuple scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(977);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.Store(proc, 5, scaleRMax);
			HalconAPI.Store(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.Store(proc, 8, scaleCMax);
			HalconAPI.Store(proc, 9, scaleCStep);
			HalconAPI.Store(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.StoreI(proc, 12, minContrast);
			HalconAPI.Store(proc, 13, genParamName);
			HalconAPI.Store(proc, 14, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Prepare a deformable model for planar uncalibrated matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		// Token: 0x060003FA RID: 1018 RVA: 0x000176D0 File Offset: 0x000158D0
		public HDeformableModel(HXLDCont contours, int numLevels, HTuple angleStart, HTuple angleExtent, double angleStep, double scaleRMin, HTuple scaleRMax, double scaleRStep, double scaleCMin, HTuple scaleCMax, double scaleCStep, string optimization, string metric, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(977);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.Store(proc, 5, scaleRMax);
			HalconAPI.StoreD(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.Store(proc, 8, scaleCMax);
			HalconAPI.StoreD(proc, 9, scaleCStep);
			HalconAPI.StoreS(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.StoreI(proc, 12, minContrast);
			HalconAPI.Store(proc, 13, genParamName);
			HalconAPI.Store(proc, 14, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Create a deformable model for calibrated perspective matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="camParam">The parameters of the internal orientation of the camera.</param>
		/// <param name="referencePose">The reference pose of the object in the reference image.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "none"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Thresholds or hysteresis thresholds for the contrast of the object in the template image. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <param name="genParamName">The parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the parameters. Default: []</param>
		// Token: 0x060003FB RID: 1019 RVA: 0x000177D8 File Offset: 0x000159D8
		public HDeformableModel(HImage template, HCamPar camParam, HPose referencePose, HTuple numLevels, HTuple angleStart, HTuple angleExtent, HTuple angleStep, double scaleRMin, HTuple scaleRMax, HTuple scaleRStep, double scaleCMin, HTuple scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, HTuple contrast, HTuple minContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(979);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.Store(proc, 0, camParam);
			HalconAPI.Store(proc, 1, referencePose);
			HalconAPI.Store(proc, 2, numLevels);
			HalconAPI.Store(proc, 3, angleStart);
			HalconAPI.Store(proc, 4, angleExtent);
			HalconAPI.Store(proc, 5, angleStep);
			HalconAPI.StoreD(proc, 6, scaleRMin);
			HalconAPI.Store(proc, 7, scaleRMax);
			HalconAPI.Store(proc, 8, scaleRStep);
			HalconAPI.StoreD(proc, 9, scaleCMin);
			HalconAPI.Store(proc, 10, scaleCMax);
			HalconAPI.Store(proc, 11, scaleCStep);
			HalconAPI.Store(proc, 12, optimization);
			HalconAPI.StoreS(proc, 13, metric);
			HalconAPI.Store(proc, 14, contrast);
			HalconAPI.Store(proc, 15, minContrast);
			HalconAPI.Store(proc, 16, genParamName);
			HalconAPI.Store(proc, 17, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(referencePose);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(minContrast);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		/// <summary>
		///   Create a deformable model for calibrated perspective matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="camParam">The parameters of the internal orientation of the camera.</param>
		/// <param name="referencePose">The reference pose of the object in the reference image.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "none"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Thresholds or hysteresis thresholds for the contrast of the object in the template image. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <param name="genParamName">The parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the parameters. Default: []</param>
		// Token: 0x060003FC RID: 1020 RVA: 0x00017950 File Offset: 0x00015B50
		public HDeformableModel(HImage template, HCamPar camParam, HPose referencePose, int numLevels, HTuple angleStart, HTuple angleExtent, double angleStep, double scaleRMin, HTuple scaleRMax, double scaleRStep, double scaleCMin, HTuple scaleCMax, double scaleCStep, string optimization, string metric, HTuple contrast, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(979);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.Store(proc, 0, camParam);
			HalconAPI.Store(proc, 1, referencePose);
			HalconAPI.StoreI(proc, 2, numLevels);
			HalconAPI.Store(proc, 3, angleStart);
			HalconAPI.Store(proc, 4, angleExtent);
			HalconAPI.StoreD(proc, 5, angleStep);
			HalconAPI.StoreD(proc, 6, scaleRMin);
			HalconAPI.Store(proc, 7, scaleRMax);
			HalconAPI.StoreD(proc, 8, scaleRStep);
			HalconAPI.StoreD(proc, 9, scaleCMin);
			HalconAPI.Store(proc, 10, scaleCMax);
			HalconAPI.StoreD(proc, 11, scaleCStep);
			HalconAPI.StoreS(proc, 12, optimization);
			HalconAPI.StoreS(proc, 13, metric);
			HalconAPI.Store(proc, 14, contrast);
			HalconAPI.StoreI(proc, 15, minContrast);
			HalconAPI.Store(proc, 16, genParamName);
			HalconAPI.Store(proc, 17, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(referencePose);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		/// <summary>
		///   Creates a deformable model for uncalibrated, perspective matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "none"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Thresholds or hysteresis thresholds for the contrast of the object in the template image. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameter. Default: []</param>
		// Token: 0x060003FD RID: 1021 RVA: 0x00017A9C File Offset: 0x00015C9C
		public HDeformableModel(HImage template, HTuple numLevels, HTuple angleStart, HTuple angleExtent, HTuple angleStep, double scaleRMin, HTuple scaleRMax, HTuple scaleRStep, double scaleCMin, HTuple scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, HTuple contrast, HTuple minContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(980);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.Store(proc, 5, scaleRMax);
			HalconAPI.Store(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.Store(proc, 8, scaleCMax);
			HalconAPI.Store(proc, 9, scaleCStep);
			HalconAPI.Store(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.Store(proc, 12, contrast);
			HalconAPI.Store(proc, 13, minContrast);
			HalconAPI.Store(proc, 14, genParamName);
			HalconAPI.Store(proc, 15, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(minContrast);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		/// <summary>
		///   Creates a deformable model for uncalibrated, perspective matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "none"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Thresholds or hysteresis thresholds for the contrast of the object in the template image. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameter. Default: []</param>
		// Token: 0x060003FE RID: 1022 RVA: 0x00017BDC File Offset: 0x00015DDC
		public HDeformableModel(HImage template, int numLevels, HTuple angleStart, HTuple angleExtent, double angleStep, double scaleRMin, HTuple scaleRMax, double scaleRStep, double scaleCMin, HTuple scaleCMax, double scaleCStep, string optimization, string metric, HTuple contrast, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(980);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.Store(proc, 5, scaleRMax);
			HalconAPI.StoreD(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.Store(proc, 8, scaleCMax);
			HalconAPI.StoreD(proc, 9, scaleCStep);
			HalconAPI.StoreS(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.Store(proc, 12, contrast);
			HalconAPI.StoreI(proc, 13, minContrast);
			HalconAPI.Store(proc, 14, genParamName);
			HalconAPI.Store(proc, 15, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		// Token: 0x060003FF RID: 1023 RVA: 0x00017CF4 File Offset: 0x00015EF4
		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = this.SerializeDeformableModel();
			byte[] value = hserializedItem;
			hserializedItem.Dispose();
			info.AddValue("data", value, typeof(byte[]));
		}

		// Token: 0x06000400 RID: 1024 RVA: 0x00017D2C File Offset: 0x00015F2C
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HDeformableModel(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = new HSerializedItem((byte[])info.GetValue("data", typeof(byte[])));
			this.DeserializeDeformableModel(hserializedItem);
			hserializedItem.Dispose();
		}

		/// <summary>Serialize object to binary stream in HALCON format</summary>
		// Token: 0x06000401 RID: 1025 RVA: 0x00017D6C File Offset: 0x00015F6C
		public new void Serialize(Stream stream)
		{
			HSerializedItem hserializedItem = this.SerializeDeformableModel();
			hserializedItem.Serialize(stream);
			hserializedItem.Dispose();
		}

		/// <summary>Deserialize object from binary stream in HALCON format</summary>
		// Token: 0x06000402 RID: 1026 RVA: 0x00017D80 File Offset: 0x00015F80
		public new static HDeformableModel Deserialize(Stream stream)
		{
			HDeformableModel hdeformableModel = new HDeformableModel();
			HSerializedItem hserializedItem = HSerializedItem.Deserialize(stream);
			hdeformableModel.DeserializeDeformableModel(hserializedItem);
			hserializedItem.Dispose();
			return hdeformableModel;
		}

		// Token: 0x06000403 RID: 1027 RVA: 0x00017DA6 File Offset: 0x00015FA6
		object ICloneable.Clone()
		{
			return this.Clone();
		}

		// Token: 0x06000404 RID: 1028 RVA: 0x00017DB0 File Offset: 0x00015FB0
		public new HDeformableModel Clone()
		{
			HSerializedItem hserializedItem = this.SerializeDeformableModel();
			HDeformableModel hdeformableModel = new HDeformableModel();
			hdeformableModel.DeserializeDeformableModel(hserializedItem);
			hserializedItem.Dispose();
			return hdeformableModel;
		}

		/// <summary>
		///   Return the origin (reference point) of a deformable model.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="row">Row coordinate of the origin of the deformable model.</param>
		/// <param name="column">Column coordinate of the origin of the deformable model.</param>
		// Token: 0x06000405 RID: 1029 RVA: 0x00017DD8 File Offset: 0x00015FD8
		public void GetDeformableModelOrigin(out double row, out double column)
		{
			IntPtr proc = HalconAPI.PreCall(957);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadD(proc, 0, num, out row);
			num = HalconAPI.LoadD(proc, 1, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set the origin (reference point) of a deformable model.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="row">Row coordinate of the origin of the deformable model.</param>
		/// <param name="column">Column coordinate of the origin of the deformable model.</param>
		// Token: 0x06000406 RID: 1030 RVA: 0x00017E30 File Offset: 0x00016030
		public void SetDeformableModelOrigin(double row, double column)
		{
			IntPtr proc = HalconAPI.PreCall(958);
			base.Store(proc, 0);
			HalconAPI.StoreD(proc, 1, row);
			HalconAPI.StoreD(proc, 2, column);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Set selected parameters of the deformable model.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="genParamName">Parameter names.</param>
		/// <param name="genParamValue">Parameter values.</param>
		// Token: 0x06000407 RID: 1031 RVA: 0x00017E74 File Offset: 0x00016074
		public void SetDeformableModelParam(HTuple genParamName, HTuple genParamValue)
		{
			IntPtr proc = HalconAPI.PreCall(959);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, genParamName);
			HalconAPI.Store(proc, 2, genParamValue);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Return the parameters of a deformable model.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="genParamName">Names of the generic parameters that are to be queried for the deformable model. Default: "angle_start"</param>
		/// <returns>Values of the generic parameters.</returns>
		// Token: 0x06000408 RID: 1032 RVA: 0x00017EC4 File Offset: 0x000160C4
		public HTuple GetDeformableModelParams(HTuple genParamName)
		{
			IntPtr proc = HalconAPI.PreCall(960);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, genParamName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the parameters of a deformable model.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="genParamName">Names of the generic parameters that are to be queried for the deformable model. Default: "angle_start"</param>
		/// <returns>Values of the generic parameters.</returns>
		// Token: 0x06000409 RID: 1033 RVA: 0x00017F1C File Offset: 0x0001611C
		public HTuple GetDeformableModelParams(string genParamName)
		{
			IntPtr proc = HalconAPI.PreCall(960);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, genParamName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the contour representation of a deformable model.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="level">Pyramid level for which the contour representation should be returned. Default: 1</param>
		/// <returns>Contour representation of the deformable model.</returns>
		// Token: 0x0600040A RID: 1034 RVA: 0x00017F6C File Offset: 0x0001616C
		public HXLDCont GetDeformableModelContours(int level)
		{
			IntPtr proc = HalconAPI.PreCall(961);
			base.Store(proc, 0);
			HalconAPI.StoreI(proc, 1, level);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HXLDCont result;
			num = HXLDCont.LoadNew(proc, 1, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Deserialize a deformable model.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="serializedItemHandle">Handle of the serialized item.</param>
		// Token: 0x0600040B RID: 1035 RVA: 0x00017FBC File Offset: 0x000161BC
		public void DeserializeDeformableModel(HSerializedItem serializedItemHandle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(963);
			HalconAPI.Store(proc, 0, serializedItemHandle);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(serializedItemHandle);
		}

		/// <summary>
		///   Serialize a deformable model.
		///   Instance represents: Handle of a model to be saved.
		/// </summary>
		/// <returns>Handle of the serialized item.</returns>
		// Token: 0x0600040C RID: 1036 RVA: 0x00018010 File Offset: 0x00016210
		public HSerializedItem SerializeDeformableModel()
		{
			IntPtr proc = HalconAPI.PreCall(964);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HSerializedItem result;
			num = HSerializedItem.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Read a deformable model from a file.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="fileName">File name.</param>
		// Token: 0x0600040D RID: 1037 RVA: 0x00018058 File Offset: 0x00016258
		public void ReadDeformableModel(string fileName)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(965);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Write a deformable model to a file.
		///   Instance represents: Handle of a model to be saved.
		/// </summary>
		/// <param name="fileName">The path and filename of the model to be saved.</param>
		// Token: 0x0600040E RID: 1038 RVA: 0x000180A4 File Offset: 0x000162A4
		public void WriteDeformableModel(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(966);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, fileName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>Free the memory of a deformable model.</summary>
		/// <param name="modelID">Handle of the model.</param>
		// Token: 0x0600040F RID: 1039 RVA: 0x000180E0 File Offset: 0x000162E0
		public static void ClearDeformableModel(HDeformableModel[] modelID)
		{
			HTuple htuple = HHandleBase.ConcatArray(modelID);
			IntPtr proc = HalconAPI.PreCall(968);
			HalconAPI.Store(proc, 0, htuple);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(modelID);
		}

		/// <summary>
		///   Free the memory of a deformable model.
		///   Instance represents: Handle of the model.
		/// </summary>
		// Token: 0x06000410 RID: 1040 RVA: 0x00018124 File Offset: 0x00016324
		public void ClearDeformableModel()
		{
			IntPtr proc = HalconAPI.PreCall(968);
			base.Store(proc, 0);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Find the best matches of a local deformable model in an image.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="image">Input image in which the model should be found.</param>
		/// <param name="vectorField">Vector field of the rectification transformation.</param>
		/// <param name="deformedContours">Contours of the found instances of the model.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.79</param>
		/// <param name="scaleRMin">Minimum scale of the model in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">Maximum scale of the model in row direction. Default: 1.0</param>
		/// <param name="scaleCMin">Minimum scale of the model in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">Maximum scale of the model in column direction. Default: 1.0</param>
		/// <param name="minScore">Minumum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 1.0</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching. Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="resultType">Switch for requested iconic result. Default: []</param>
		/// <param name="genParamName">The general parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the general parameters. Default: []</param>
		/// <param name="score">Scores of the found instances of the model.</param>
		/// <param name="row">Row coordinates of the found instances of the model.</param>
		/// <param name="column">Column coordinates of the found instances of the model.</param>
		/// <returns>Rectified image of the found model.</returns>
		// Token: 0x06000411 RID: 1041 RVA: 0x00018158 File Offset: 0x00016358
		public HImage FindLocalDeformableModel(HImage image, out HImage vectorField, out HXLDCont deformedContours, double angleStart, double angleExtent, double scaleRMin, double scaleRMax, double scaleCMin, double scaleCMax, double minScore, int numMatches, double maxOverlap, int numLevels, double greediness, HTuple resultType, HTuple genParamName, HTuple genParamValue, out HTuple score, out HTuple row, out HTuple column)
		{
			IntPtr proc = HalconAPI.PreCall(969);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleRMin);
			HalconAPI.StoreD(proc, 4, scaleRMax);
			HalconAPI.StoreD(proc, 5, scaleCMin);
			HalconAPI.StoreD(proc, 6, scaleCMax);
			HalconAPI.StoreD(proc, 7, minScore);
			HalconAPI.StoreI(proc, 8, numMatches);
			HalconAPI.StoreD(proc, 9, maxOverlap);
			HalconAPI.StoreI(proc, 10, numLevels);
			HalconAPI.StoreD(proc, 11, greediness);
			HalconAPI.Store(proc, 12, resultType);
			HalconAPI.Store(proc, 13, genParamName);
			HalconAPI.Store(proc, 14, genParamValue);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(resultType);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HImage result;
			num = HImage.LoadNew(proc, 1, num, out result);
			num = HImage.LoadNew(proc, 2, num, out vectorField);
			num = HXLDCont.LoadNew(proc, 3, num, out deformedContours);
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out score);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out row);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out column);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Find the best matches of a calibrated deformable model in an image and return their 3D pose.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="image">Input image in which the model should be found.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.78</param>
		/// <param name="scaleRMin">Minimum scale of the model in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">Maximum scale of the model in row direction. Default: 1.0</param>
		/// <param name="scaleCMin">Minimum scale of the model in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">Maximum scale of the model in column direction. Default: 1.0</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 1.0</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="genParamName">The general parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the general parameters. Default: []</param>
		/// <param name="covPose">6 standard deviations or 36 covariances of the pose parameters.</param>
		/// <param name="score">Score of the found instances of the model.</param>
		/// <returns>Pose of the object.</returns>
		// Token: 0x06000412 RID: 1042 RVA: 0x000182A8 File Offset: 0x000164A8
		public HPose[] FindPlanarCalibDeformableModel(HImage image, double angleStart, double angleExtent, double scaleRMin, double scaleRMax, double scaleCMin, double scaleCMax, double minScore, int numMatches, double maxOverlap, HTuple numLevels, double greediness, HTuple genParamName, HTuple genParamValue, out HTuple covPose, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(970);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleRMin);
			HalconAPI.StoreD(proc, 4, scaleRMax);
			HalconAPI.StoreD(proc, 5, scaleCMin);
			HalconAPI.StoreD(proc, 6, scaleCMax);
			HalconAPI.StoreD(proc, 7, minScore);
			HalconAPI.StoreI(proc, 8, numMatches);
			HalconAPI.StoreD(proc, 9, maxOverlap);
			HalconAPI.Store(proc, 10, numLevels);
			HalconAPI.StoreD(proc, 11, greediness);
			HalconAPI.Store(proc, 12, genParamName);
			HalconAPI.Store(proc, 13, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out covPose);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			HPose[] result = HPose.SplitArray(data);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Find the best matches of a calibrated deformable model in an image and return their 3D pose.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="image">Input image in which the model should be found.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.78</param>
		/// <param name="scaleRMin">Minimum scale of the model in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">Maximum scale of the model in row direction. Default: 1.0</param>
		/// <param name="scaleCMin">Minimum scale of the model in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">Maximum scale of the model in column direction. Default: 1.0</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 1.0</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="genParamName">The general parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the general parameters. Default: []</param>
		/// <param name="covPose">6 standard deviations or 36 covariances of the pose parameters.</param>
		/// <param name="score">Score of the found instances of the model.</param>
		/// <returns>Pose of the object.</returns>
		// Token: 0x06000413 RID: 1043 RVA: 0x000183B8 File Offset: 0x000165B8
		public HPose FindPlanarCalibDeformableModel(HImage image, double angleStart, double angleExtent, double scaleRMin, double scaleRMax, double scaleCMin, double scaleCMax, double minScore, int numMatches, double maxOverlap, int numLevels, double greediness, HTuple genParamName, HTuple genParamValue, out HTuple covPose, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(970);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleRMin);
			HalconAPI.StoreD(proc, 4, scaleRMax);
			HalconAPI.StoreD(proc, 5, scaleCMin);
			HalconAPI.StoreD(proc, 6, scaleCMax);
			HalconAPI.StoreD(proc, 7, minScore);
			HalconAPI.StoreI(proc, 8, numMatches);
			HalconAPI.StoreD(proc, 9, maxOverlap);
			HalconAPI.StoreI(proc, 10, numLevels);
			HalconAPI.StoreD(proc, 11, greediness);
			HalconAPI.Store(proc, 12, genParamName);
			HalconAPI.Store(proc, 13, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HPose result;
			num = HPose.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out covPose);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Find the best matches of a planar projective invariant deformable model in an image.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="image">Input image in which the model should be found.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.78</param>
		/// <param name="scaleRMin">Minimum scale of the model in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">Maximum scale of the model in row direction. Default: 1.0</param>
		/// <param name="scaleCMin">Minimum scale of the model in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">Maximum scale of the model in column direction. Default: 1.0</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 1.0</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="genParamName">The general parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the general parameters. Default: []</param>
		/// <param name="score">Score of the found instances of the model.</param>
		/// <returns>Homographies between model and found instances.</returns>
		// Token: 0x06000414 RID: 1044 RVA: 0x000184BC File Offset: 0x000166BC
		public HHomMat2D[] FindPlanarUncalibDeformableModel(HImage image, double angleStart, double angleExtent, double scaleRMin, double scaleRMax, double scaleCMin, double scaleCMax, double minScore, int numMatches, double maxOverlap, HTuple numLevels, double greediness, HTuple genParamName, HTuple genParamValue, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(971);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleRMin);
			HalconAPI.StoreD(proc, 4, scaleRMax);
			HalconAPI.StoreD(proc, 5, scaleCMin);
			HalconAPI.StoreD(proc, 6, scaleCMax);
			HalconAPI.StoreD(proc, 7, minScore);
			HalconAPI.StoreI(proc, 8, numMatches);
			HalconAPI.StoreD(proc, 9, maxOverlap);
			HalconAPI.Store(proc, 10, numLevels);
			HalconAPI.StoreD(proc, 11, greediness);
			HalconAPI.Store(proc, 12, genParamName);
			HalconAPI.Store(proc, 13, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HTuple data;
			num = HTuple.LoadNew(proc, 0, num, out data);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			HHomMat2D[] result = HHomMat2D.SplitArray(data);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Find the best matches of a planar projective invariant deformable model in an image.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="image">Input image in which the model should be found.</param>
		/// <param name="angleStart">Smallest rotation of the model. Default: -0.39</param>
		/// <param name="angleExtent">Extent of the rotation angles. Default: 0.78</param>
		/// <param name="scaleRMin">Minimum scale of the model in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">Maximum scale of the model in row direction. Default: 1.0</param>
		/// <param name="scaleCMin">Minimum scale of the model in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">Maximum scale of the model in column direction. Default: 1.0</param>
		/// <param name="minScore">Minimum score of the instances of the model to be found. Default: 0.5</param>
		/// <param name="numMatches">Number of instances of the model to be found (or 0 for all matches). Default: 1</param>
		/// <param name="maxOverlap">Maximum overlap of the instances of the model to be found. Default: 1.0</param>
		/// <param name="numLevels">Number of pyramid levels used in the matching (and lowest pyramid level to use if $|NumLevels| = 2$). Default: 0</param>
		/// <param name="greediness">"Greediness" of the search heuristic (0: safe but slow; 1: fast but matches may be missed). Default: 0.9</param>
		/// <param name="genParamName">The general parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the general parameters. Default: []</param>
		/// <param name="score">Score of the found instances of the model.</param>
		/// <returns>Homographies between model and found instances.</returns>
		// Token: 0x06000415 RID: 1045 RVA: 0x000185B8 File Offset: 0x000167B8
		public HHomMat2D FindPlanarUncalibDeformableModel(HImage image, double angleStart, double angleExtent, double scaleRMin, double scaleRMax, double scaleCMin, double scaleCMax, double minScore, int numMatches, double maxOverlap, int numLevels, double greediness, HTuple genParamName, HTuple genParamValue, out HTuple score)
		{
			IntPtr proc = HalconAPI.PreCall(971);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.StoreD(proc, 1, angleStart);
			HalconAPI.StoreD(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, scaleRMin);
			HalconAPI.StoreD(proc, 4, scaleRMax);
			HalconAPI.StoreD(proc, 5, scaleCMin);
			HalconAPI.StoreD(proc, 6, scaleCMax);
			HalconAPI.StoreD(proc, 7, minScore);
			HalconAPI.StoreI(proc, 8, numMatches);
			HalconAPI.StoreD(proc, 9, maxOverlap);
			HalconAPI.StoreI(proc, 10, numLevels);
			HalconAPI.StoreD(proc, 11, greediness);
			HalconAPI.Store(proc, 12, genParamName);
			HalconAPI.Store(proc, 13, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			HHomMat2D result;
			num = HHomMat2D.LoadNew(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Set the metric of a local deformable model that was created from XLD contours.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="image">Input image used for the determination of the polarity.</param>
		/// <param name="vectorField">Vector field of the local deformation.</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		// Token: 0x06000416 RID: 1046 RVA: 0x000186A8 File Offset: 0x000168A8
		public void SetLocalDeformableModelMetric(HImage image, HImage vectorField, string metric)
		{
			IntPtr proc = HalconAPI.PreCall(972);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.Store(proc, 2, vectorField);
			HalconAPI.StoreS(proc, 1, metric);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
			GC.KeepAlive(vectorField);
		}

		/// <summary>
		///   Set the metric of a planar calibrated deformable model that was created from XLD contours.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="image">Input image used for the determination of the polarity.</param>
		/// <param name="pose">Pose of the model in the image.</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		// Token: 0x06000417 RID: 1047 RVA: 0x00018700 File Offset: 0x00016900
		public void SetPlanarCalibDeformableModelMetric(HImage image, HPose pose, string metric)
		{
			IntPtr proc = HalconAPI.PreCall(973);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.Store(proc, 1, pose);
			HalconAPI.StoreS(proc, 2, metric);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(pose);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Set the metric of a planar uncalibrated deformable model that was created from XLD contours.
		///   Instance represents: Handle of the model.
		/// </summary>
		/// <param name="image">Input image used for the determination of the polarity.</param>
		/// <param name="homMat2D">Transformation matrix.</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		// Token: 0x06000418 RID: 1048 RVA: 0x00018764 File Offset: 0x00016964
		public void SetPlanarUncalibDeformableModelMetric(HImage image, HHomMat2D homMat2D, string metric)
		{
			IntPtr proc = HalconAPI.PreCall(974);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, image);
			HalconAPI.Store(proc, 1, homMat2D);
			HalconAPI.StoreS(proc, 2, metric);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(homMat2D);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
			GC.KeepAlive(image);
		}

		/// <summary>
		///   Prepare a deformable model for local deformable matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		// Token: 0x06000419 RID: 1049 RVA: 0x000187C8 File Offset: 0x000169C8
		public void CreateLocalDeformableModelXld(HXLDCont contours, HTuple numLevels, HTuple angleStart, HTuple angleExtent, HTuple angleStep, double scaleRMin, HTuple scaleRMax, HTuple scaleRStep, double scaleCMin, HTuple scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(975);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.Store(proc, 5, scaleRMax);
			HalconAPI.Store(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.Store(proc, 8, scaleCMax);
			HalconAPI.Store(proc, 9, scaleCStep);
			HalconAPI.Store(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.StoreI(proc, 12, minContrast);
			HalconAPI.Store(proc, 13, genParamName);
			HalconAPI.Store(proc, 14, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Prepare a deformable model for local deformable matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		// Token: 0x0600041A RID: 1050 RVA: 0x000188F0 File Offset: 0x00016AF0
		public void CreateLocalDeformableModelXld(HXLDCont contours, int numLevels, HTuple angleStart, HTuple angleExtent, double angleStep, double scaleRMin, HTuple scaleRMax, double scaleRStep, double scaleCMin, HTuple scaleCMax, double scaleCStep, string optimization, string metric, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(975);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.Store(proc, 5, scaleRMax);
			HalconAPI.StoreD(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.Store(proc, 8, scaleCMax);
			HalconAPI.StoreD(proc, 9, scaleCStep);
			HalconAPI.StoreS(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.StoreI(proc, 12, minContrast);
			HalconAPI.Store(proc, 13, genParamName);
			HalconAPI.Store(proc, 14, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Prepare a deformable model for planar calibrated matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="camParam">The parameters of the internal orientation of the camera.</param>
		/// <param name="referencePose">The reference pose of the object.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameter. Default: []</param>
		// Token: 0x0600041B RID: 1051 RVA: 0x000189F8 File Offset: 0x00016BF8
		public void CreatePlanarCalibDeformableModelXld(HXLDCont contours, HCamPar camParam, HPose referencePose, HTuple numLevels, HTuple angleStart, HTuple angleExtent, HTuple angleStep, double scaleRMin, HTuple scaleRMax, HTuple scaleRStep, double scaleCMin, HTuple scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(976);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.Store(proc, 0, camParam);
			HalconAPI.Store(proc, 1, referencePose);
			HalconAPI.Store(proc, 2, numLevels);
			HalconAPI.Store(proc, 3, angleStart);
			HalconAPI.Store(proc, 4, angleExtent);
			HalconAPI.Store(proc, 5, angleStep);
			HalconAPI.StoreD(proc, 6, scaleRMin);
			HalconAPI.Store(proc, 7, scaleRMax);
			HalconAPI.Store(proc, 8, scaleRStep);
			HalconAPI.StoreD(proc, 9, scaleCMin);
			HalconAPI.Store(proc, 10, scaleCMax);
			HalconAPI.Store(proc, 11, scaleCStep);
			HalconAPI.Store(proc, 12, optimization);
			HalconAPI.StoreS(proc, 13, metric);
			HalconAPI.StoreI(proc, 14, minContrast);
			HalconAPI.Store(proc, 15, genParamName);
			HalconAPI.Store(proc, 16, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(referencePose);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Prepare a deformable model for planar calibrated matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="camParam">The parameters of the internal orientation of the camera.</param>
		/// <param name="referencePose">The reference pose of the object.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameter. Default: []</param>
		// Token: 0x0600041C RID: 1052 RVA: 0x00018B58 File Offset: 0x00016D58
		public void CreatePlanarCalibDeformableModelXld(HXLDCont contours, HCamPar camParam, HPose referencePose, int numLevels, HTuple angleStart, HTuple angleExtent, double angleStep, double scaleRMin, HTuple scaleRMax, double scaleRStep, double scaleCMin, HTuple scaleCMax, double scaleCStep, string optimization, string metric, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(976);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.Store(proc, 0, camParam);
			HalconAPI.Store(proc, 1, referencePose);
			HalconAPI.StoreI(proc, 2, numLevels);
			HalconAPI.Store(proc, 3, angleStart);
			HalconAPI.Store(proc, 4, angleExtent);
			HalconAPI.StoreD(proc, 5, angleStep);
			HalconAPI.StoreD(proc, 6, scaleRMin);
			HalconAPI.Store(proc, 7, scaleRMax);
			HalconAPI.StoreD(proc, 8, scaleRStep);
			HalconAPI.StoreD(proc, 9, scaleCMin);
			HalconAPI.Store(proc, 10, scaleCMax);
			HalconAPI.StoreD(proc, 11, scaleCStep);
			HalconAPI.StoreS(proc, 12, optimization);
			HalconAPI.StoreS(proc, 13, metric);
			HalconAPI.StoreI(proc, 14, minContrast);
			HalconAPI.Store(proc, 15, genParamName);
			HalconAPI.Store(proc, 16, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(referencePose);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Prepare a deformable model for planar uncalibrated matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		// Token: 0x0600041D RID: 1053 RVA: 0x00018C94 File Offset: 0x00016E94
		public void CreatePlanarUncalibDeformableModelXld(HXLDCont contours, HTuple numLevels, HTuple angleStart, HTuple angleExtent, HTuple angleStep, double scaleRMin, HTuple scaleRMax, HTuple scaleRStep, double scaleCMin, HTuple scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(977);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.Store(proc, 5, scaleRMax);
			HalconAPI.Store(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.Store(proc, 8, scaleCMax);
			HalconAPI.Store(proc, 9, scaleCStep);
			HalconAPI.Store(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.StoreI(proc, 12, minContrast);
			HalconAPI.Store(proc, 13, genParamName);
			HalconAPI.Store(proc, 14, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Prepare a deformable model for planar uncalibrated matching from XLD contours.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="contours">Input contours that will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "auto"</param>
		/// <param name="metric">Match metric. Default: "ignore_local_polarity"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: 5</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		// Token: 0x0600041E RID: 1054 RVA: 0x00018DBC File Offset: 0x00016FBC
		public void CreatePlanarUncalibDeformableModelXld(HXLDCont contours, int numLevels, HTuple angleStart, HTuple angleExtent, double angleStep, double scaleRMin, HTuple scaleRMax, double scaleRStep, double scaleCMin, HTuple scaleCMax, double scaleCStep, string optimization, string metric, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(977);
			HalconAPI.Store(proc, 1, contours);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.Store(proc, 5, scaleRMax);
			HalconAPI.StoreD(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.Store(proc, 8, scaleCMax);
			HalconAPI.StoreD(proc, 9, scaleCStep);
			HalconAPI.StoreS(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.StoreI(proc, 12, minContrast);
			HalconAPI.Store(proc, 13, genParamName);
			HalconAPI.Store(proc, 14, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(contours);
		}

		/// <summary>
		///   Creates a deformable model for local, deformable matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "none"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Thresholds or hysteresis thresholds for the contrast of the object in the template image. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		// Token: 0x0600041F RID: 1055 RVA: 0x00018EC4 File Offset: 0x000170C4
		public void CreateLocalDeformableModel(HImage template, HTuple numLevels, HTuple angleStart, HTuple angleExtent, HTuple angleStep, double scaleRMin, HTuple scaleRMax, HTuple scaleRStep, double scaleCMin, HTuple scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, HTuple contrast, HTuple minContrast, HTuple genParamName, HTuple genParamValue)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(978);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.Store(proc, 5, scaleRMax);
			HalconAPI.Store(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.Store(proc, 8, scaleCMax);
			HalconAPI.Store(proc, 9, scaleCStep);
			HalconAPI.Store(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.Store(proc, 12, contrast);
			HalconAPI.Store(proc, 13, minContrast);
			HalconAPI.Store(proc, 14, genParamName);
			HalconAPI.Store(proc, 15, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(minContrast);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		/// <summary>
		///   Creates a deformable model for local, deformable matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "none"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Thresholds or hysteresis thresholds for the contrast of the object in the template image. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameters. Default: []</param>
		// Token: 0x06000420 RID: 1056 RVA: 0x00019004 File Offset: 0x00017204
		public void CreateLocalDeformableModel(HImage template, int numLevels, HTuple angleStart, HTuple angleExtent, double angleStep, double scaleRMin, HTuple scaleRMax, double scaleRStep, double scaleCMin, HTuple scaleCMax, double scaleCStep, string optimization, string metric, HTuple contrast, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(978);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.Store(proc, 5, scaleRMax);
			HalconAPI.StoreD(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.Store(proc, 8, scaleCMax);
			HalconAPI.StoreD(proc, 9, scaleCStep);
			HalconAPI.StoreS(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.Store(proc, 12, contrast);
			HalconAPI.StoreI(proc, 13, minContrast);
			HalconAPI.Store(proc, 14, genParamName);
			HalconAPI.Store(proc, 15, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		/// <summary>
		///   Create a deformable model for calibrated perspective matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="camParam">The parameters of the internal orientation of the camera.</param>
		/// <param name="referencePose">The reference pose of the object in the reference image.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "none"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Thresholds or hysteresis thresholds for the contrast of the object in the template image. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <param name="genParamName">The parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the parameters. Default: []</param>
		// Token: 0x06000421 RID: 1057 RVA: 0x0001911C File Offset: 0x0001731C
		public void CreatePlanarCalibDeformableModel(HImage template, HCamPar camParam, HPose referencePose, HTuple numLevels, HTuple angleStart, HTuple angleExtent, HTuple angleStep, double scaleRMin, HTuple scaleRMax, HTuple scaleRStep, double scaleCMin, HTuple scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, HTuple contrast, HTuple minContrast, HTuple genParamName, HTuple genParamValue)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(979);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.Store(proc, 0, camParam);
			HalconAPI.Store(proc, 1, referencePose);
			HalconAPI.Store(proc, 2, numLevels);
			HalconAPI.Store(proc, 3, angleStart);
			HalconAPI.Store(proc, 4, angleExtent);
			HalconAPI.Store(proc, 5, angleStep);
			HalconAPI.StoreD(proc, 6, scaleRMin);
			HalconAPI.Store(proc, 7, scaleRMax);
			HalconAPI.Store(proc, 8, scaleRStep);
			HalconAPI.StoreD(proc, 9, scaleCMin);
			HalconAPI.Store(proc, 10, scaleCMax);
			HalconAPI.Store(proc, 11, scaleCStep);
			HalconAPI.Store(proc, 12, optimization);
			HalconAPI.StoreS(proc, 13, metric);
			HalconAPI.Store(proc, 14, contrast);
			HalconAPI.Store(proc, 15, minContrast);
			HalconAPI.Store(proc, 16, genParamName);
			HalconAPI.Store(proc, 17, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(referencePose);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(minContrast);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		/// <summary>
		///   Create a deformable model for calibrated perspective matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="camParam">The parameters of the internal orientation of the camera.</param>
		/// <param name="referencePose">The reference pose of the object in the reference image.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in the column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "none"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Thresholds or hysteresis thresholds for the contrast of the object in the template image. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <param name="genParamName">The parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the parameters. Default: []</param>
		// Token: 0x06000422 RID: 1058 RVA: 0x00019294 File Offset: 0x00017494
		public void CreatePlanarCalibDeformableModel(HImage template, HCamPar camParam, HPose referencePose, int numLevels, HTuple angleStart, HTuple angleExtent, double angleStep, double scaleRMin, HTuple scaleRMax, double scaleRStep, double scaleCMin, HTuple scaleCMax, double scaleCStep, string optimization, string metric, HTuple contrast, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(979);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.Store(proc, 0, camParam);
			HalconAPI.Store(proc, 1, referencePose);
			HalconAPI.StoreI(proc, 2, numLevels);
			HalconAPI.Store(proc, 3, angleStart);
			HalconAPI.Store(proc, 4, angleExtent);
			HalconAPI.StoreD(proc, 5, angleStep);
			HalconAPI.StoreD(proc, 6, scaleRMin);
			HalconAPI.Store(proc, 7, scaleRMax);
			HalconAPI.StoreD(proc, 8, scaleRStep);
			HalconAPI.StoreD(proc, 9, scaleCMin);
			HalconAPI.Store(proc, 10, scaleCMax);
			HalconAPI.StoreD(proc, 11, scaleCStep);
			HalconAPI.StoreS(proc, 12, optimization);
			HalconAPI.StoreS(proc, 13, metric);
			HalconAPI.Store(proc, 14, contrast);
			HalconAPI.StoreI(proc, 15, minContrast);
			HalconAPI.Store(proc, 16, genParamName);
			HalconAPI.Store(proc, 17, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(camParam);
			HalconAPI.UnpinTuple(referencePose);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		/// <summary>
		///   Creates a deformable model for uncalibrated, perspective matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "none"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Thresholds or hysteresis thresholds for the contrast of the object in the template image. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameter. Default: []</param>
		// Token: 0x06000423 RID: 1059 RVA: 0x000193E0 File Offset: 0x000175E0
		public void CreatePlanarUncalibDeformableModel(HImage template, HTuple numLevels, HTuple angleStart, HTuple angleExtent, HTuple angleStep, double scaleRMin, HTuple scaleRMax, HTuple scaleRStep, double scaleCMin, HTuple scaleCMax, HTuple scaleCStep, HTuple optimization, string metric, HTuple contrast, HTuple minContrast, HTuple genParamName, HTuple genParamValue)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(980);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.Store(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.Store(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.Store(proc, 5, scaleRMax);
			HalconAPI.Store(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.Store(proc, 8, scaleCMax);
			HalconAPI.Store(proc, 9, scaleCStep);
			HalconAPI.Store(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.Store(proc, 12, contrast);
			HalconAPI.Store(proc, 13, minContrast);
			HalconAPI.Store(proc, 14, genParamName);
			HalconAPI.Store(proc, 15, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(numLevels);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(angleStep);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleRStep);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(scaleCStep);
			HalconAPI.UnpinTuple(optimization);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(minContrast);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}

		/// <summary>
		///   Creates a deformable model for uncalibrated, perspective matching.
		///   Modified instance represents: Handle of the model.
		/// </summary>
		/// <param name="template">Input image whose domain will be used to create the model.</param>
		/// <param name="numLevels">Maximum number of pyramid levels. Default: "auto"</param>
		/// <param name="angleStart">This parameter is not used. Default: []</param>
		/// <param name="angleExtent">This parameter is not used. Default: []</param>
		/// <param name="angleStep">Step length of the angles (resolution). Default: "auto"</param>
		/// <param name="scaleRMin">Minimum scale of the pattern in row direction. Default: 1.0</param>
		/// <param name="scaleRMax">This parameter is not used. Default: []</param>
		/// <param name="scaleRStep">Scale step length (resolution) in row direction. Default: "auto"</param>
		/// <param name="scaleCMin">Minimum scale of the pattern in column direction. Default: 1.0</param>
		/// <param name="scaleCMax">This parameter is not used. Default: []</param>
		/// <param name="scaleCStep">Scale step length (resolution) in column direction. Default: "auto"</param>
		/// <param name="optimization">Kind of optimization used for generating the model. Default: "none"</param>
		/// <param name="metric">Match metric. Default: "use_polarity"</param>
		/// <param name="contrast">Thresholds or hysteresis thresholds for the contrast of the object in the template image. Default: "auto"</param>
		/// <param name="minContrast">Minimum contrast of the objects in the search images. Default: "auto"</param>
		/// <param name="genParamName">The generic parameter names. Default: []</param>
		/// <param name="genParamValue">Values of the generic parameter. Default: []</param>
		// Token: 0x06000424 RID: 1060 RVA: 0x00019520 File Offset: 0x00017720
		public void CreatePlanarUncalibDeformableModel(HImage template, int numLevels, HTuple angleStart, HTuple angleExtent, double angleStep, double scaleRMin, HTuple scaleRMax, double scaleRStep, double scaleCMin, HTuple scaleCMax, double scaleCStep, string optimization, string metric, HTuple contrast, int minContrast, HTuple genParamName, HTuple genParamValue)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(980);
			HalconAPI.Store(proc, 1, template);
			HalconAPI.StoreI(proc, 0, numLevels);
			HalconAPI.Store(proc, 1, angleStart);
			HalconAPI.Store(proc, 2, angleExtent);
			HalconAPI.StoreD(proc, 3, angleStep);
			HalconAPI.StoreD(proc, 4, scaleRMin);
			HalconAPI.Store(proc, 5, scaleRMax);
			HalconAPI.StoreD(proc, 6, scaleRStep);
			HalconAPI.StoreD(proc, 7, scaleCMin);
			HalconAPI.Store(proc, 8, scaleCMax);
			HalconAPI.StoreD(proc, 9, scaleCStep);
			HalconAPI.StoreS(proc, 10, optimization);
			HalconAPI.StoreS(proc, 11, metric);
			HalconAPI.Store(proc, 12, contrast);
			HalconAPI.StoreI(proc, 13, minContrast);
			HalconAPI.Store(proc, 14, genParamName);
			HalconAPI.Store(proc, 15, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(angleStart);
			HalconAPI.UnpinTuple(angleExtent);
			HalconAPI.UnpinTuple(scaleRMax);
			HalconAPI.UnpinTuple(scaleCMax);
			HalconAPI.UnpinTuple(contrast);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(template);
		}
	}
}
